// AI助手组件
Component({
  properties: {
    visible: {
      type: Boolean,
      value: false,
      observer: function(newVal, oldVal) {
        console.log('AI助手可见性变化:', oldVal, '->', newVal, '时间:', new Date().toLocaleTimeString());
        
        // 记录最新的可见性状态
        this._lastVisibleState = newVal;
        
        // 同步内部状态
        this.setData({
          _internalVisible: newVal
        });
        
        if (newVal === true) {
          // 设置初始显示在底部
          this.setData({
            scrollToBottom: true
          }, () => {
            // 延迟执行滚动，确保DOM已更新，但不使用动画效果
            setTimeout(() => {
              this._directScrollToBottom();
            }, 100);
          });
          
          // 如果是第一次打开且没有消息历史，显示欢迎消息
          if (this.data.messages.length === 0) {
            this._addAssistantMessage('你好！我是你的学习助手，可以回答关于课程、预约、积分等方面的问题。有什么我能帮助你的吗？');
          }
        } else {
          // 隐藏时中止任何进行中的请求
          this._abortRequest();
        }
      }
    }
  },
  
  data: {
    inputValue: '', // 输入框的值
    messages: [], // 消息记录
    isTyping: false, // 是否正在打字回复
    scrollHeight: 0,
    hasInput: false, // 跟踪输入框是否有内容
    networkError: false, // 是否发生网络错误
    scrollViewId: 'message-bottom', // 用于scroll-into-view
    scrollTop: 0, // 用于控制滚动位置
    scrollToBottom: false, // 控制是否应该立即显示在底部
    currentStreamMessage: null, // 当前正在流式接收的消息
    activeMessageId: null, // 当前活动消息ID
    abortController: null, // 用于中止请求
    streamBuffer: '', // 用于累积当前流式内容
    parsedContent: {}, // 存储解析后的markdown内容
    keyboardHeight: 0, // 键盘高度
    isKeyboardShow: false, // 是否显示键盘
    isComponentReady: false, // 组件是否已经准备就绪
    _internalVisible: false, // 内部可见性状态，用于处理外部visible属性的变化
    _lastVisibleState: false // 用于存储最新的可见性状态
  },
  
  lifetimes: {
    attached() {
      console.log('AI助手组件已附加到页面 - 时间:', new Date().toLocaleTimeString());
      // 获取系统信息，计算消息容器高度
      const systemInfo = wx.getSystemInfoSync();
      const windowHeight = systemInfo.windowHeight;
      // 计算消息容器高度 (总高度减去标题栏和输入区的高度)
      const scrollHeight = windowHeight * 0.8 - 160;
      
      // 尝试从本地存储恢复消息历史记录
      let savedMessages = [];
      try {
        const savedMessagesStr = wx.getStorageSync('ai_assistant_messages');
        if (savedMessagesStr) {
          savedMessages = JSON.parse(savedMessagesStr);
        }
      } catch (e) {
        console.error('恢复消息记录失败:', e);
      }
      
      this.setData({ 
        scrollHeight,
        messages: savedMessages,
        scrollToBottom: true, // 设置初始显示在底部
        isComponentReady: true
      });

      // 监听键盘高度变化
      wx.onKeyboardHeightChange(res => {
        const isKeyboardShow = res.height > 0;
        console.log('键盘高度变化:', res.height, isKeyboardShow ? '显示' : '隐藏');
        
        // 计算新的消息区域高度，考虑键盘高度
        let adjustedScrollHeight = this.data.scrollHeight;
        if (isKeyboardShow) {
          // 如果键盘显示，调整消息区域高度，留出足够空间给固定在底部的输入框
          const systemInfo = wx.getSystemInfoSync();
          const windowHeight = systemInfo.windowHeight;
          
          // 计算内容区域的新高度，保留足够空间给输入框和键盘
          adjustedScrollHeight = windowHeight * 0.8 - 260; // 输入区域大约100rpx + 安全距离
        }
        
        this.setData({
          keyboardHeight: res.height,
          isKeyboardShow: isKeyboardShow,
          scrollHeight: adjustedScrollHeight
        });
        
        // 键盘弹出时，稍微延迟后滚动到底部
        if (isKeyboardShow) {
          setTimeout(() => {
            this._directScrollToBottom();
          }, 300);
        }
      });
    },
    
    ready() {
      console.log('AI助手组件准备完成 - 时间:', new Date().toLocaleTimeString());
    },
    
    detached() {
      const timestamp = new Date().toLocaleTimeString();
      let reason = "未知原因";
      
      // 尝试确定组件被移除的原因
      const currentPage = getCurrentPages().pop();
      const pageRoute = currentPage ? currentPage.route : '未知页面';
      
      if (pageRoute.includes('index/index')) {
        if (this._lastVisibleState) {
          reason = "首页切换Tab后返回，但组件仍应保持可见";
        } else {
          reason = "首页正常移除不可见组件";
        }
      } else {
        reason = `离开页面: ${pageRoute}`;
      }
      
      console.log(`AI助手组件被移除 - 时间: ${timestamp}, 原因: ${reason}`);
      console.log(`组件最后的可见状态: ${this._lastVisibleState ? '可见' : '隐藏'}`);
      
      // 保存消息历史记录
      this._saveMessages();
      
      // 确保组件销毁时中止请求
      this._abortRequest();
      
      // 移除键盘高度监听器
      wx.offKeyboardHeightChange();
    }
  },
  
  pageLifetimes: {
    show() {
      // 页面被展示时触发
      console.log('AI助手组件所在页面显示 - 时间:', new Date().toLocaleTimeString());
      console.log('页面显示时组件状态:', this.properties.visible ? '可见' : '隐藏');
      
      // 延迟处理，确保页面已加载完成
      setTimeout(() => {
        // 如果在页面返回时应该是可见的，但可能因为某些原因被隐藏
        if (this.properties.visible && this.data.isComponentReady) {
          console.log('页面显示后强制刷新AI助手状态');
          
          // 触发一次自身的可见性观察器
          this.setData({
            _internalVisible: true
          }, () => {
            this._directScrollToBottom();
          });
        }
      }, 300);
    },
    hide() {
      // 页面被隐藏时触发
      console.log('AI助手组件所在页面隐藏 - 时间:', new Date().toLocaleTimeString());
      
      // 确保中止请求
      this._abortRequest();
      
      // 记录隐藏前的状态，以便可能的恢复
      this._lastVisibleState = this.properties.visible;
      console.log('页面隐藏时记录状态:', this._lastVisibleState ? '可见' : '隐藏');
    }
  },
  
  methods: {
    // 中止当前请求
    _abortRequest() {
      if (this.data.abortController) {
        try {
          this.data.abortController.abort();
        } catch (e) {
          console.error('中止请求失败:', e);
        }
        this.setData({ abortController: null });
      }
    },
    
    // 关闭助手面板
    onClose() {
      console.log('AI助手关闭按钮被点击');
      this._abortRequest(); // 中止请求
      this.setData({ visible: false });
      this.triggerEvent('close');
    },
    
    // 处理输入框内容变化
    onInputChange(e) {
      const inputValue = e.detail.value;
      const hasInput = inputValue.trim().length > 0;
      
      this.setData({
        inputValue,
        hasInput
      });
    },
    
    // 发送消息
    onSend() {
      const { inputValue, messages } = this.data;
      if (!inputValue.trim()) return;
      
      // 先中止可能存在的请求
      this._abortRequest();
      
      // 生成唯一ID作为消息标识
      const messageId = `msg-${Date.now()}`;
      
      // 添加用户消息
      const userMessage = {
        id: messageId,
        content: inputValue,
        isUser: true,
        time: this._formatTime(new Date())
      };
      
      this.setData({
        messages: [...messages, userMessage],
        inputValue: '',
        hasInput: false,
        isTyping: true,
        networkError: false, // 重置网络错误状态
        scrollViewId: 'message-bottom',
        scrollToBottom: true // 设置需要滚动到底部
      }, () => {
        // 直接显示在底部，不使用动画
        this._directScrollToBottom();
        this._saveMessages();
        this._fetchStreamResponse(inputValue);
      });
    },
    
    // 使用wx.request获取流式响应
    _fetchStreamResponse(userInput) {
      const app = getApp();
      const apiBaseUrl = app.globalData.apiBaseUrl;
      const assistantMessageId = `msg-${Date.now()}`;
      
      // 获取当前用户ID，用于记录日志
      const userId = app.globalData && app.globalData.userInfo 
        ? app.globalData.userInfo.id 
        : 'anonymous';
      
      // 创建一个初始的AI消息（会随着流式响应逐步更新）
      const initialAssistantMessage = {
        id: assistantMessageId,
        content: '思考中',
        isUser: false,
        time: this._formatTime(new Date()),
        isStreaming: true, // 标记为正在流式接收中
        isThinking: true // 标记为正在思考中
      };
      
      // 添加初始AI消息
      this.setData({
        messages: [...this.data.messages, initialAssistantMessage],
        activeMessageId: assistantMessageId,
        currentStreamMessage: initialAssistantMessage,
        streamBuffer: '' // 重置流式缓冲区
      }, () => {
        this._directScrollToBottom();
      });
      
      console.log('准备获取token，API地址:', `${apiBaseUrl}/api/assistant/token`);
      
      // 先通过服务端获取认证信息
      wx.request({
        url: `${apiBaseUrl}/api/assistant/token`,
        method: 'GET',
        success: (res) => {
          if (res.statusCode === 200 && res.data.success && res.data.token) {
            // 获取到token，进行直接请求
            this._directRequestBaiduApi(userInput, res.data.token, userId);
          } else {
            console.error('获取认证信息失败:', res);
            this._handleStreamError();
          }
        },
        fail: (err) => {
          console.error('获取认证token失败:', err);
          this._handleStreamError();
        }
      });
    },
    
    // 直接请求百度API实现流式传输
    _directRequestBaiduApi(userInput, token, userId) {
      // 构建历史消息数组，确保符合百度API要求的格式
      const historyMessages = this._buildHistoryMessages();
      
      // 添加最新的用户消息
      historyMessages.push({ role: 'user', content: userInput });
      
      console.log('发送请求，消息数量:', historyMessages.length);

      // 创建请求任务
      const requestTask = wx.request({
        url: 'https://qianfan.baidubce.com/v2/chat/completions',
        method: 'POST',
        header: {
          'Content-Type': 'application/json',
          'Authorization': token
        },
        data: {
          model: 'ernie-3.5-8k',
          messages: historyMessages,
          temperature: 0.7,
          top_p: 0.8,
          stream: true
        },
        enableChunked: true, // 开启流式传输
        responseType: 'arraybuffer',
        success: (res) => {
          // 只有在非流式情况下才会执行，即enableChunked无效的情况
          console.log('请求成功，使用非流式响应处理', res.statusCode);
          if (res.statusCode === 200) {
            try {
              // 判断是否是有效的ArrayBuffer
              if (res.data && (res.data instanceof ArrayBuffer || ArrayBuffer.isView(res.data))) {
                const content = this._arrayBufferToString(res.data);
                this._clearThinkingState();
                
                // 解析Markdown并更新消息
                const parsedContent = this._parseMarkdown(content);
                this._updateStreamingMessage(content);
              } else if (typeof res.data === 'string') {
                // 如果直接返回字符串，直接使用
                this._clearThinkingState();
                const parsedContent = this._parseMarkdown(res.data);
                this._updateStreamingMessage(res.data);
              } else if (res.data && typeof res.data === 'object') {
                // 处理JSON对象响应
                let content = '';
                if (res.data.result) {
                  content = res.data.result;
                } else if (res.data.choices && res.data.choices[0] && res.data.choices[0].message) {
                  content = res.data.choices[0].message.content;
                }
                
                if (content) {
                  this._clearThinkingState();
                  const parsedContent = this._parseMarkdown(content);
                  this._updateStreamingMessage(content);
                } else {
                  throw new Error('无法从响应中提取内容');
                }
              } else {
                throw new Error('无法解析响应数据类型');
              }
              
              this._finishStreamingMessage();
            } catch (error) {
              console.error('处理非流式响应失败:', error);
              this._handleStreamError();
            }
          } else {
            console.error('请求失败，状态码:', res.statusCode);
            this._handleStreamError();
          }
        },
        fail: (err) => {
          console.error('百度API请求失败:', err);
          this._handleStreamError();
        },
        complete: () => {
          console.log('请求结束，思考状态:', this.data.isThinking, '缓冲区长度:', this.data.streamBuffer?.length);
          if (this.data.isThinking) {
            // 如果还在思考状态，说明没有正常流式传输
            this._handleStreamError();
          } else if (this.data.streamBuffer && this.data.activeMessageId) {
            // 请求完成且有内容，确保流式消息正确结束
            this._finishStreamingMessage();
          }
        }
      });
      
      // 设置分块数据处理
      if (requestTask && requestTask.onChunkReceived) {
        requestTask.onChunkReceived(this._handleChunkData.bind(this));
      } else {
        console.warn('当前环境不支持onChunkReceived，将使用普通请求方式');
      }
      
      // 保存请求任务引用
      this.setData({ abortController: requestTask });
    },
    
    // 处理分块数据
    _handleChunkData(res) {
      try {
        // 将ArrayBuffer转换为字符串
        const chunkText = this._arrayBufferToString(res.data);
        const lines = chunkText.split('\n');
        
        for (const line of lines) {
          if (line.startsWith('data:')) {
            try {
              const jsonStr = line.slice(5).trim();
              if (jsonStr === '[DONE]') {
                // 流式数据结束，结束流式消息
                this._finishStreamingMessage();
                continue;
              }
              
              const data = JSON.parse(jsonStr);
              if (data.choices && data.choices[0] && data.choices[0].delta && data.choices[0].delta.content) {
                const content = data.choices[0].delta.content;
                
                // 如果是第一个块，清除"思考中"状态
                if (this.data.isThinking) {
                  this._clearThinkingState();
                }
                
                // 累积内容到缓冲区
                const newBuffer = this.data.streamBuffer + content;
                this.setData({ streamBuffer: newBuffer });
                
                // 更新消息显示（内部会处理Markdown解析）
                this._updateStreamingMessage(newBuffer);
              }
            } catch (e) {
              console.error('解析数据块失败:', e);
              // 继续处理其他块，不中断
            }
          }
        }
      } catch (error) {
        console.error('处理数据块时发生错误:', error);
      }
    },
    
    // 将ArrayBuffer转换为字符串
    _arrayBufferToString(buffer) {
      // 防御性检查，确保buffer是ArrayBuffer或ArrayBufferView
      if (!buffer) {
        console.warn('收到空buffer');
        return '';
      }
      
      try {
        // 检查是否为ArrayBuffer或ArrayBufferView
        if (buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer)) {
          // 尝试使用TextDecoder
          return new TextDecoder('utf-8').decode(buffer);
        } else if (typeof buffer === 'string') {
          // 如果已经是字符串，直接返回
          return buffer;
        } else {
          console.warn('无法识别的数据类型:', typeof buffer);
          return JSON.stringify(buffer);
        }
      } catch (e) {
        console.error('TextDecoder失败:', e);
        // 降级方案
        try {
          if (buffer instanceof ArrayBuffer) {
            const bytes = new Uint8Array(buffer);
            let rawStr = '';
            for (let i = 0; i < bytes.length; i++) {
              rawStr += String.fromCharCode(bytes[i]);
            }
            return decodeURIComponent(escape(rawStr));
          } else {
            return String(buffer);
          }
        } catch (error) {
          console.error('手动转换失败:', error);
          return '无法解析响应数据';
        }
      }
    },
    
    // 清除思考中状态
    _clearThinkingState() {
      const { messages, activeMessageId } = this.data;
      
      if (!activeMessageId) return;
      
      // 寻找并更新活动消息，清除"思考中..."
      const updatedMessages = messages.map(msg => {
        if (msg.id === activeMessageId && msg.isThinking) {
          return {
            ...msg,
            content: '', // 清空"思考中..."
            isThinking: false
          };
        }
        return msg;
      });
      
      this.setData({
        messages: updatedMessages,
        isThinking: false
      });
    },
    
    // 更新正在流式接收的消息
    _updateStreamingMessage(content) {
      const { messages, activeMessageId } = this.data;
      
      if (!activeMessageId) return;
      
      // 解析Markdown内容
      const parsedContent = this._parseMarkdown(content);
      
      // 寻找并更新活动消息
      const updatedMessages = messages.map(msg => {
        if (msg.id === activeMessageId) {
          return {
            ...msg,
            content: content,
            parsedContent: parsedContent,
            isThinking: false
          };
        }
        return msg;
      });
      
      this.setData({
        messages: updatedMessages,
        scrollToBottom: true
      }, () => {
        this._directScrollToBottom();
      });
    },
    
    // Markdown解析方法
    _parseMarkdown(text) {
      if (!text) return '';
      
      try {
        // 1. 预处理代码块和行内代码，防止它们内部的特殊字符被解析
        const codeBlocks = [];
        const inlineCodes = [];
        
        // 处理代码块，用占位符替换
        let processedText = text.replace(/```([\s\S]*?)```/g, (match, codeContent) => {
          const id = `CODE_BLOCK_${codeBlocks.length}`;
          codeBlocks.push(codeContent);
          return id;
        });
        
        // 处理行内代码，用占位符替换
        processedText = processedText.replace(/`([^`]+)`/g, (match, codeContent) => {
          const id = `INLINE_CODE_${inlineCodes.length}`;
          inlineCodes.push(codeContent);
          return id;
        });
        
        // 2. 转义HTML特殊字符，防止XSS
        processedText = processedText
          .replace(/&/g, '&amp;')
          .replace(/</g, '&lt;')
          .replace(/>/g, '&gt;')
          .replace(/"/g, '&quot;')
          .replace(/'/g, '&#39;');
        
        // 3. 解析各种Markdown元素
        
        // 处理标题 (h1-h6)
        processedText = processedText.replace(/^(#{1,6})\s+(.+?)$/gm, (match, hashes, content) => {
          const level = hashes.length;
          return `<h${level}>${content}</h${level}>`;
        });
        
        // 处理粗体 (** 和 __)
        processedText = processedText.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
        processedText = processedText.replace(/__(.*?)__/g, '<strong>$1</strong>');
        
        // 处理斜体 (* 和 _)，注意避免与粗体冲突
        processedText = processedText.replace(/\*([^\*]+)\*/g, '<em>$1</em>');
        processedText = processedText.replace(/_([^_]+)_/g, '<em>$1</em>');
        
        // 处理列表
        // 无序列表
        processedText = processedText.replace(/^\s*[-*]\s+(.+?)$/gm, '<li>$1</li>');
        // 有序列表
        processedText = processedText.replace(/^\s*\d+\.\s+(.+?)$/gm, '<li>$1</li>');
        
        // 处理链接
        processedText = processedText.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
        
        // 处理分隔线
        processedText = processedText.replace(/^(\s*[-*_]){3,}\s*$/gm, '<hr>');
        
        // 4. 还原代码块和行内代码
        // 还原代码块
        processedText = processedText.replace(/CODE_BLOCK_(\d+)/g, (match, index) => {
          const codeContent = codeBlocks[parseInt(index)]
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#39;');
          return `<pre><code>${codeContent}</code></pre>`;
        });
        
        // 还原行内代码
        processedText = processedText.replace(/INLINE_CODE_(\d+)/g, (match, index) => {
          const codeContent = inlineCodes[parseInt(index)]
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#39;');
          return `<code>${codeContent}</code>`;
        });
        
        // 5. 处理换行和段落
        // 处理换行，确保保留段落
        processedText = processedText
          .replace(/\n\n+/g, '</p><p>') // 多个换行视为段落分隔
          .replace(/\n/g, '<br>'); // 单个换行
        
        // 确保段落最开始有开始标签，最后有结束标签
        if (!processedText.startsWith('<h') && !processedText.startsWith('<p>')) {
          processedText = '<p>' + processedText;
        }
        if (!processedText.endsWith('</p>') && !processedText.endsWith('</pre>')) {
          processedText = processedText + '</p>';
        }
        
        // 6. 包装整个内容在div中，确保在rich-text中正确渲染
        return `<div>${processedText}</div>`;
        
      } catch (error) {
        console.error('Markdown解析错误:', error);
        // 如果解析失败，返回原始文本（转义HTML实体）
        return text
          .replace(/&/g, '&amp;')
          .replace(/</g, '&lt;')
          .replace(/>/g, '&gt;')
          .replace(/"/g, '&quot;')
          .replace(/'/g, '&#39;');
      }
    },
    
    // 结束流式消息
    _finishStreamingMessage() {
      const { messages, activeMessageId } = this.data;
      
      if (activeMessageId) {
        // 更新活动消息状态为非流式
        const updatedMessages = messages.map(msg => {
          if (msg.id === activeMessageId) {
            return {
              ...msg,
              isStreaming: false
            };
          }
          return msg;
        });
        
        this.setData({
          messages: updatedMessages,
          activeMessageId: null,
          currentStreamMessage: null,
          isTyping: false,
          abortController: null,
          isStreaming: false,
          streamBuffer: ''
        }, () => {
          // 保存消息历史
          this._saveMessages();
        });
      } else {
        this.setData({
          activeMessageId: null,
          currentStreamMessage: null,
          isTyping: false,
          abortController: null,
          isStreaming: false,
          streamBuffer: ''
        });
      }
    },
    
    // 处理流式响应错误
    _handleStreamError() {
      this.setData({
        networkError: true,
        isTyping: false
      });
      
      // 显示错误消息
      const errorMsg = "抱歉，网络连接出现问题，无法获取回复。请检查网络连接后重试。";
      
      // 如果当前有活动消息，更新它
      if (this.data.activeMessageId) {
        const { messages, activeMessageId } = this.data;
        const updatedMessages = messages.map(msg => {
          if (msg.id === activeMessageId) {
            return {
              ...msg,
              content: errorMsg,
              isStreaming: false,
              isThinking: false,
              isError: true
            };
          }
          return msg;
        });
        
        this.setData({
          messages: updatedMessages,
          activeMessageId: null,
          currentStreamMessage: null,
          abortController: null,
          isStreaming: false,
          streamBuffer: ''
        }, () => {
          this._saveMessages();
        });
      } else {
        // 如果没有活动消息，添加一个错误消息
        this._addAssistantMessage(errorMsg, true);
      }
    },
    
    // 添加助手消息
    _addAssistantMessage(content, isError = false) {
      const { messages } = this.data;
      const messageId = `msg-${Date.now()}`;
      
      // 解析Markdown内容
      const parsedContent = this._parseMarkdown(content);
      
      const assistantMessage = {
        id: messageId,
        content: content,
        parsedContent: parsedContent,
        isUser: false,
        time: this._formatTime(new Date()),
        isError: isError
      };
      
      this.setData({
        messages: [...messages, assistantMessage],
        isTyping: false,
        scrollViewId: 'message-bottom',
        scrollToBottom: true // 设置需要滚动到底部
      }, () => {
        // 直接显示在底部，不使用动画
        this._directScrollToBottom();
        this._saveMessages();
      });
    },
    
    // 保存消息到本地存储
    _saveMessages() {
      try {
        wx.setStorageSync('ai_assistant_messages', JSON.stringify(this.data.messages));
      } catch (e) {
        console.error('保存消息记录失败:', e);
      }
    },
    
    // 直接滚动到底部，不使用动画
    _directScrollToBottom() {
      if (!this.data.scrollToBottom) return;
      
      // 延迟很短时间确保DOM更新完成
      setTimeout(() => {
        // 使用很大的scrollTop值确保滚动到底部
        const randomScrollPosition = 100000 + Math.floor(Math.random() * 1000);
        this.setData({
          scrollTop: randomScrollPosition,
          scrollWithAnimation: false
        });
        
        // 重置状态
        setTimeout(() => {
          this.setData({
            scrollToBottom: false
          });
        }, 100);
      }, 50);
    },
    
    // 滚动到对话底部（带动画，仅当用户主动滚动时使用）
    _scrollToBottom() {
      setTimeout(() => {
        // 使用很大的scrollTop值确保滚动到底部
        const randomScrollPosition = 100000 + Math.floor(Math.random() * 1000);
        this.setData({
          scrollTop: randomScrollPosition,
          scrollWithAnimation: true
        });
      }, 100);
    },
    
    // 清空历史记录
    onClearHistory() {
      wx.showModal({
        title: '清空聊天记录',
        content: '确定要清空所有聊天记录吗？',
        confirmColor: '#5271FF',
        success: (res) => {
          if (res.confirm) {
            // 先中止任何进行中的请求
            this._abortRequest();
            
            // 添加过渡效果
            const fadeOutMessages = this.data.messages.map(msg => ({
              ...msg,
              fadeOut: true
            }));
            
            this.setData({ 
              messages: fadeOutMessages 
            });
            
            // 延迟执行清除操作，让过渡效果可见
            setTimeout(() => {
              this.setData({ messages: [] });
              wx.removeStorageSync('ai_assistant_messages');
              
              // 显示欢迎消息
              this._addAssistantMessage('你好！我是你的学习助手，可以回答关于课程、预约、积分等方面的问题。有什么我能帮助你的吗？');
              
              // 显示轻提示
              wx.showToast({
                title: '已清空聊天记录',
                icon: 'success',
                duration: 1500
              });
            }, 300);
          }
        }
      });
    },
    
    // 格式化时间
    _formatTime(date) {
      const hours = date.getHours().toString().padStart(2, '0');
      const minutes = date.getMinutes().toString().padStart(2, '0');
      return `${hours}:${minutes}`;
    },
    
    // 重试发送上一条消息
    retryLastMessage() {
      if (this.data.networkError && this.data.messages.length > 0) {
        const userMessages = this.data.messages.filter(msg => msg.isUser);
        if (userMessages.length > 0) {
          const lastUserMessage = userMessages[userMessages.length - 1];
          this.setData({
            isTyping: true,
            networkError: false
          }, () => {
            this._fetchStreamResponse(lastUserMessage.content);
          });
        }
      }
    },
    
    // 处理建议问题点击
    onSuggestionTap(e) {
      const text = e.currentTarget.dataset.text;
      if (text) {
        this.setData({
          inputValue: text,
          hasInput: true
        }, () => {
          this.onSend();
        });
      }
    },
    
    // 停止事件冒泡
    stopPropagation(e) {
      // 阻止事件冒泡到父元素
    },
    
    // 输入框获取焦点
    _onInputFocus() {
      console.log('输入框获取焦点');
      
      // 防止黑色蒙层问题
      wx.pageScrollTo({
        scrollTop: 0,
        duration: 0
      });
      
      // 确保滚动到底部
      this.setData({
        scrollToBottom: true
      });
      
      // 延迟滚动到底部，确保键盘弹出后执行
      setTimeout(() => {
        this._directScrollToBottom();
      }, 300);
    },
    
    // 输入框失去焦点
    _onInputBlur() {
      console.log('输入框失去焦点');
      
      // 在失去焦点时重置键盘状态和滚动区域高度
      setTimeout(() => {
        const systemInfo = wx.getSystemInfoSync();
        const windowHeight = systemInfo.windowHeight;
        const scrollHeight = windowHeight * 0.8 - 160;
        
        this.setData({
          isKeyboardShow: false,
          keyboardHeight: 0,
          scrollHeight: scrollHeight
        });
      }, 100);
    },
    
    // 构建历史消息数组
    _buildHistoryMessages() {
      const { messages } = this.data;
      return messages.map(msg => ({
        role: msg.isUser ? 'user' : 'assistant',
        content: msg.content
      }));
    }
  }
}); 